

//#include "..\scr_func\a_math.h"
//#include "..\scr_func\a_roarr.h"
//#include "..\scr_func\a_rwarr.h"
//#include "..\scr_func\a_serv.h"


//========================================
//		a_math.h
//========================================


template <typename T>
T Min_3 (const T a, const T b, const T c);

template <typename T>
T Max_3 (const T a, const T b, const T c);

template <typename T>
void swap_a_b (T *pa, T *pb);
//Функція обміну змінних

int Fibonachi(int count);

template <typename T>
T find_min(const T &a, const T &b);

template <typename T>
T find_max(const T &a, const T &b);

template <typename T>
T Max_Array (T *data, size_t size);

template <typename T>
T Min_Array (T *data, size_t size);

unsigned long long Factorial (int *x);
//Факторіал числа переданого по вказівнику

//template <typename T>
double pow (float *a, int *n);
//Піднесення числа у степіть

long long  pow (int *a, int *n);
//Піднесення числа у степіть



//========================================
//		a_serv.h
//========================================

template <typename T>
void Error_Enter (T *perr_sel, size_t *pit);
//Повідомлення невірного вводу

void Line (int w, char sym, bool paus=false);
//функція малювання лінії вказаного розміну та вказаним символом і зупинкою програми



//========================================
//		a_roarr.h
//========================================

template <typename T>
void Show_Array(T data[], const int size, const int col=5);
//Відображення елементів масиву по n колонок


template <typename T>
int Binary_Search (const T *data, const T value, size_t left, size_t right);
//Бінарний пошук у відсортованиму масиві без рекурсії (лекційний матеріал)
// O(log(2)n = O(4)  2^4 = 16


template <typename T>
int Find_Cell (T cell, T *arr, int start, int size);
//Функція пошуку елемента у масиві та повернення
//індексу першого знайденого елементу. Якщо не знайдено то -1


template <typename T>
int BinarySearch (const T data[], int left, int right, const T value);
//Бінарний пошук з використанням рекурсії (лекційний матеріал)
//Масив повинен бути відсортований
// O(log(2)n = O(4)  2^4 = 16


template <typename T>
int Linear_Search (const T data[], const int size, const T value);
//Лінійний пошук по масиву O(n)


template <typename T, typename P>
void Show_Struct(T *data, P *count_A, P *count_B, const size_t size, const int col);
//Відображення елементів 3-х масивів у 3 стрічки по n колонок

template <typename T>
void Finde_Minus(T *data, size_t size, int &l_minus, int &r_minus);
//фукція знаходження крайніх від"ємних чивел масиву
//у функцію передаються посилання на змінні для збереження індексів крайнії елементів



//========================================
//		a_rwarr.h
//========================================

template <typename T>
void Random_Array (T data[], const int size, int range_a, int range_b, int fraction=0, bool sign_num= false);
//Заповнення масиву випадковими числами вказаного діапазону
//та заданою кількістю знаків у дробових числах


template <typename T>
void Random_Table 	(	
						T ** data,
						size_t * index_col, 
						size_t row, 
						size_t col, 
						int range_a, 
						int range_b, 
						const int fraction= 0, 
						const bool sign_num= false
					);
//Заповнення динамічного масиву (N x M) випадковими числами вказаного діапазону
//та заданою кількістю знаків у дробових числах


template <typename T>
void Quick_Sort(T data[], const int left, const int right);
//СОРТИРОВКА ХОАРА - найшвидший метод сортування O(n*log(2)n) = O(16)

template <typename T>
void Quick_Sort_par (T data[], const int left, const int right, bool type_sort= false);
//СОРТИРОВКА ХОАРА - найшвидший метод сортування O(n*log(2)n) = O(16)
//сотрування з параметром по зростанню (по замовчуванню) чи по спаданню (true)
//Доцільніше використати 2 різні функції для збереження швидкості. 


template <typename T>
void Quick_Sort_2(T data[], const int left, const int right, bool type_sort = false);
//СОРТИРОВКА ХОАРА - найшвидший метод сортування O(n*log(2)n) = O(16)


template <typename T>
void BobleSortDuo(T data[], const int size);


template <typename T>
void ShakeSort (T data[], const int size);


template <typename T>
void Insert_Sort (T data[], const int size);
//СОРТУВАННЯ ВСТАВКОЮ 16/02/2014

template <typename T>
void Insert_Sort_par (T data[], const int size, bool type_sort= true);
//СОРТУВАННЯ ВСТАВКОЮ 16/02/2014


template <typename T>
void BolbSort(T data[], const int size);


template <typename T>
void SortData(T data[], const int size);


template <typename TA>
void Manual_Infill_Array (TA data[], int size, int col= 5);


template <typename T>
void Copy_Array (T *arr_src, T *arr_tar, const size_t size);
//Копіювання масиву


template <typename T>
void Shuflle_Array (T *data, size_t size, size_t pass= 1);
//Функція перемішування елементів масиву 
//pass - встановлення кількості проходів перемішування


//==============================================

#include "a_math.h"
#include "a_roarr.h"
#include "a_rwarr.h"
#include "a_serv.h"
